var sz_jdsjzx = [];//节点频率中心

function PLDX(gjZhi, plZhi, bmZhi) {
    this.gj = gjZhi;
    this.pl = plZhi;
    this.bm = bmZhi;
    this.ztShuliang = plZhi * 2;//这个频率有多少个状态 [状态数量]
    this.dZTsj = 1000000 / this.ztShuliang;//1秒*1000*1000=微秒。 1秒内，1个状态占的时间长。[单状态时间]
    this.shijianxian = [];//时间线。把所有状态的时间点，放到同一条线上。先后发生顺序放到数组里面。
    let _shijian = 0;
    //for (let i = 0; i < this.pl; i++) {//1个频率分两半，我们只研究前一半。后一半是一样的。
    for (let i = 0; i <10; i++) {
        _shijian = this.dZTsj * (i + 1);
        this.shijianxian.push(_shijian.toFixed());
    }
    //把本频率所有的时间节点，加入到sz去。
    //为了方便这个节点时间属于xx管脚，我们把管脚别名，频率，都纳入去（用一个对象装一个节点时间）
    this.hqShijianxianPLDX = function (sz) {
        let _n_bm = this.bm;
        let _n_pl = this.pl;
        let _n_gj = this.gj;
        let _n_sjjd;
        for (let i = 0; i < this.shijianxian.length; i++) {
            _n_sjjd = Number(this.shijianxian[i]);
            sz.push({
                pl: _n_pl,  //频率
                bm: _n_bm,  //别名
                gj: _n_gj,   //原始管脚
                sjJD: _n_sjjd//单个时间节点
            })
        }
    }
}

/**
 * 针对 对象数组进行排序
 */
function dxPX(dx, dxSZzhi) {
    for (var i = 0; i < dx.length; i++) {
        for (var j = 0; j < dx.length - 1 - i; j++) {
            if (dx[j][dxSZzhi] > dx[j + 1][dxSZzhi]) {
                let temp = dx[j];
                dx[j] = dx[j + 1];
                dx[j + 1] = temp;
            }
        }
    }
}

/**
 * 合并 时间线
 */
function hebingShijianxian(szDX, dxShijiandian) {
    let qian = 0;
    let dx;
    let shijiandian;
    for (var i = 0; i < szDX.length; i++) {
        dx = szDX[i];//取出数组的一个对象
        shijiandian = dx[dxShijiandian];//取出对象里面的时间节点。
        dx.xsjxjd = Number(shijiandian - qian);//加入新的属性，代表【新时间线节点】，当前节点的位置。
        qian = shijiandian;//当前这个，是下一个的节点时间要减去的。
    }
}

/**
 * 换算 新时间线
 */
function huansuanXshijianJD(szDX, xsjjd) {
    let dx;
    let shijiandian;
    for (var i = 0; i < szDX.length; i++) {

        dx = szDX[i];//取出数组的一个对象
        shijiandian = dx[xsjjd];//Number() ;//取出对象里面的新时间节点。

        if (shijiandian) {
            //换算：把新时间节点，换成 【我们自己定义的延时函数需要的参数】
            dx.ychsCS = Number(((shijiandian - 9) / 8).toFixed());
        } else {
            dx.ychsCS = 0;
        }
    }
}

/**
 * 调整 时间线的延迟函数的参数。在指定的时间节点里面，我们需要执行 管脚的附值，比如 led=~led; 这会耗去我们的时间。
 */
function tiaozhengYanchihanshuCS(szDX, csZhi) {
    let dx;
    let zhi;
    let ling = 0;//记录参数为0的，表示那个时间点，要同时执行多个 led灯的状态取反。 
    let zuihouDX;//记录最后一个时间点的对象。
    for (var i = 0; i < szDX.length; i++) {
        dx = szDX[i];//取出数组的一个对象
        zhi = dx[csZhi];//取出对象里面的 参数值
        if (zhi == 0) {
            ling++;
            dx.tzcs = '';
        } else {
            zuihouDX = dx;
            dx.tzcs = zhi - ling - 1;//加入新的属性，用于记录 调整后的参数。
            ling = 0;
        }
    }
    //为了后一半频率着想，如果最后同时执行多个 led=xx，那么，作为后一半，应该继续减去多出的时间。
    //这里，直接在上半场，最后一个不为0的时间点，减去多出的指令时间
    if (ling) {
        zuihouDX.tzcs = zuihouDX.tzcs - ling;
    }
}
//生成频率代码
function dmsc(szDX) {
    let dm = '';
    let dx;

    for (var i = 0; i < szDX.length; i++) {
        dx = szDX[i];//取出数组的一个对象

        if (dx.tzcs) {
            dm += 'sj(' + dx.tzcs + ');<br/>' + dx.bm + '=!' + dx.bm + ';<br/>';
        } else {
            dm += dx.bm + '=!' + dx.bm + ';<br/>';//不需要延迟。表示同一个时间点
        }

    }
    $('#dmzxZJ').html(dm);//频率的代码
}

//生成 定义管脚的代码
function dmsc_dyGJ() {
    let gjdm = '';
    let dx;
    for (let i = 0; i < this.sz_gjzx.length; i++) {
        dx = this.sz_gjzx[i];//取出数组的一个对象
        gjdm += 'sbit ' + dx.hqBM() + '=' + dx.hqGJ() + ';<br/>'
    }
    $('#gjDMzx').html(gjdm);//定义管脚的代码
}

/**
 * 频率分析
 */
function pvfx() {

    sz_jdsjzx.length = 0;
    let _pldx;//频率对象
    let _gjdx;//管脚对象
    for (let i = 0; i < this.sz_gjzx.length; i++) {
        _gjdx = this.sz_gjzx[i];
        if (_gjdx.hqPL() && _gjdx.hqBM()) {
            _pldx = new PLDX(_gjdx.hqGJ(), _gjdx.hqPL(), _gjdx.hqBM());//分析频率，每个状态占的时间。
            _pldx.hqShijianxianPLDX(sz_jdsjzx);//把所有频率的时间节点放到一个数组里面
        }
    }
    dxPX(sz_jdsjzx, 'sjJD')//排序。从小到大。
    hebingShijianxian(sz_jdsjzx, 'sjJD');//合并时间节点。
    huansuanXshijianJD(sz_jdsjzx, 'xsjxjd');//换算新时间节点 成我们延迟函数需要的的参数。
    tiaozhengYanchihanshuCS(sz_jdsjzx, 'ychsCS');//调整换算的参数。


// 生成代码。
    //---------------------------------- 
    dmsc_dyGJ();//生成定义管脚的代码。
    dmsc(sz_jdsjzx);//生成频率代码。
    //----------------------------------   
    let jgBiaoge = "";
    for (let i = 0; i < sz_jdsjzx.length; i++) {
        jgBiaoge += cjJGTr(sz_jdsjzx[i]);
    }
    cjJGTable(jgBiaoge);
}



//===================================================================================
